home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / NextAnswers / 1721_Encoding_Foundation_classes_with_Distributed_Objects.rtfd / FoundationExtensionsPrivate.m < prev    next >
Text File  |  1995-05-08  |  4KB  |  171 lines
  1. /*
  2.  *  Private classes for the compatibility routines between the old DO
  3.  *  mechanisms and the new Foundation objects.
  4.  *
  5.  *  No guarantee is made for the fitness of this code for any particular
  6.  *  use.  No warranty expressed or implied.  Use at your own risk!
  7.  *
  8.  *  Randy Tidd
  9.  *  NeXT Premium Developer Support
  10.  */
  11. #import "FoundationExtensionsPrivate.h"
  12. #import <remote/transport.h>
  13. #import <foundation/NSUtilities.h>
  14. #import <foundation/NSException.h>
  15.  
  16. @implementation _NSArrayPlaceHolder
  17.  
  18. - initWithArray:(NSArray *)anArray
  19. {
  20.     [super init];
  21.  
  22.     array = [anArray copy];
  23.  
  24.     return self;
  25. }
  26.  
  27. - free
  28. {
  29.     [array release];
  30.  
  31.     return [super free];
  32. }
  33.  
  34. - encodeUsing:(id <NXEncoding>)portal
  35. {
  36.     unsigned count, i;
  37.  
  38.     /*
  39.      *  First encode the count
  40.      */
  41.     count = [array count];
  42.     [portal encodeData:&count ofType:"i"];
  43.  
  44.     /*
  45.      *  Then encode the objects one by one
  46.      */
  47.     for(i=0; i<[array count]; i++) {
  48.     [portal encodeObject:[array objectAtIndex:i]];
  49.     }
  50.  
  51.     return self;
  52. }
  53.  
  54. - decodeUsing:(id <NXDecoding>)portal
  55. {
  56.     NSMutableArray *newArray = nil;
  57.     unsigned count, i;
  58.  
  59.     /*
  60.      *  We encoded the count first, and here it is
  61.      */
  62.     [portal decodeData:&count ofType:"i"];
  63.  
  64.     newArray = [NSMutableArray arrayWithCapacity:count];
  65.  
  66.     /*
  67.      *  Decode the objects one by one and add them to the array
  68.      */
  69.    for(i=0; i<count; i++) {
  70.     [newArray addObject:[portal decodeObject]];
  71.     }
  72.  
  73.     /*
  74.      *  We return our mutable array instance here even though we might
  75.      *  be the placeholder for a regular NSArray.  There is usually no
  76.      *  harm in returning a mutable array in place of an immutable array.
  77.      *  If there is, you need to implement some smarts here to return an
  78.      *  instance of the appropriate class.
  79.      */
  80.     return newArray;
  81. }
  82.  
  83. @end
  84.  
  85. @implementation _NSDictionaryPlaceHolder
  86.  
  87. - initWithDictionary:(NSDictionary *)aDictionary
  88. {
  89.     [super init];
  90.  
  91.     dictionary = [aDictionary copy];
  92.  
  93.     return self;
  94. }
  95.  
  96. - free
  97. {
  98.     [dictionary release];
  99.  
  100.     return [super free];
  101. }
  102.  
  103. - encodeUsing:(id <NXEncoding>)portal
  104. {
  105.     unsigned count;
  106.     NSEnumerator *enumerator = [dictionary keyEnumerator];
  107.     NSString *key;
  108.  
  109.     /*
  110.      *  First encode the count
  111.      */
  112.     count = [dictionary count];
  113.     [portal encodeData:&count ofType:"i"];
  114.  
  115.     /*
  116.      *  Then encode the objects one by one
  117.      */
  118.    while(key = [enumerator nextObject]) {
  119.     [portal encodeObject:key];
  120.     [portal encodeObject:[dictionary objectForKey:key]];
  121.     }
  122.  
  123.     return self;
  124. }
  125.  
  126. - decodeUsing:(id <NXDecoding>)portal
  127. {
  128.     NSMutableDictionary *newDictionary = nil;
  129.     unsigned count, i;
  130.  
  131.     /*
  132.      *  We encoded the count first, and here it is
  133.      */
  134.     [portal decodeData:&count ofType:"i"];
  135.  
  136.     newDictionary = [NSMutableDictionary dictionaryWithCapacity:count];
  137.  
  138.     /*
  139.      *  Decode the objects one by one and add them to the array
  140.      */
  141.     for(i=0; i<count; i++) {
  142.     id newKey, newObject;
  143.  
  144.     newKey = [portal decodeObject];
  145.     newObject = [portal decodeObject];
  146.  
  147.     if(!newKey || !newObject) {
  148.             /*
  149.              *  This should never happen, or we're in trouble.
  150.              */
  151.         [NSException raise:NSInternalInconsistencyException format:@"%s: %s: can't decode key or object",
  152.          isa->name, sel_getName(_cmd)];
  153.     }
  154.     else {
  155.         [newDictionary setObject:newObject forKey:newKey];
  156.     }
  157.     }
  158.  
  159.     /*
  160.      *  We return our mutable dictionary instance here even though we might
  161.      *  be the placeholder for a regular NSDictionary.  There is usually no
  162.      *  harm in returning a mutable dictionary in place of an immutable one.
  163.      *  If there is, you need to implement some smarts here to return an
  164.      *  instance of the appropriate class.
  165.      */
  166.     return newDictionary;
  167. }
  168.  
  169. @end
  170.  
  171.